using UnityEngine;
using System.Collections;

public class Movement : MonoBehaviour {

	/* Necessaire pour le saut */
	const double g= 9.81 ;
	const float v_inite= 0.25f ;
	const float v_initSaut= 5.0f ;
	// const float angle_init= 1.0f ;
	
	// const float angle_max= Mathf.PI / 6.0f ;
	// const float angle_min= 5.0f * Mathf.PI / 6.0f ;

	const float angle_min= -Mathf.PI / 2.0f ;
	const float angle_max= -Mathf.PI / 6.0f ;

	float mouvement ;
	float dtime, timeDepart, timeCurrent ;
	float currentPosX, currentPosY ; // Position du joueur au moment du saut
	// float currentAngle= -Mathf.PI / 2.0f ;
	float currentAngle ;

	double posRelX ;
	double posRelY ;

	bool isJump ;
	bool isDeplacement ;

	/*Nécessaire pour le déplacement */

	Vector3 mvt ;
	const float f_vitesseMax= 5 ;
	float f_vitesseCourrante= 0 ;

	// Utilisé pour la nouvelle position du héros
	double v_x ;
	double v_y ;


	/*-----------------------------------------*/
	// Use this for initialization
	/*-----------------------------------------*/
	void Start () {
		mouvement= 0.0f ;
		dtime= 0.0f ;
		currentPosX= -1.0f ;
		currentPosY= -1.0f ;
		isJump= false ;
//		idDeplacement= false ;
	}


	/*-----------------------------------------*/
	// Fonction déplacement 
	/*-----------------------------------------*/
	void deplacement ()
	{
		if ( !isDeplacement ) {
			Debug.Log ("lolilol") ;
			isDeplacement= !isDeplacement ;				// Le joueur se déplace.
			timeDepart= Time.deltaTime ;				// On garde en mémoire le temps auquel le joueur a commencer à bouger.
		}
		else {
			// isDeplacement= !isDeplacement ;
			f_vitesseCourrante= 0 ;
		}

		timeCurrent= Time.deltaTime  ;					// On garde en mémoire le temps courrant, afin d'interpoler la vitesse.

		// Si le temps maximum est ateint,alors l'angle de saut et lavitesse de déplacement atteignent leur valeur max.
		if ( timeCurrent - timeDepart > 5 ) {
			currentAngle= angle_min ;
			f_vitesseCourrante= f_vitesseMax ; 
		}
		else {
			// Sinon, on calcule l'angle courrant et la vitesse courrante au temps timeCurrent.
			currentAngle= ( angle_min - angle_max ) * ( timeCurrent - timeDepart ) / timeDepart ;	
			f_vitesseCourrante= f_vitesseMax * ( timeCurrent - timeDepart ) / timeDepart ;
		}

		// Selon la direction, la vitesse varie.
		if ( Input.GetKey(KeyCode.LeftArrow) ) {

			mvt= new Vector3(f_vitesseCourrante, 0, 0) ;
		
		} else if ( Input.GetKey(KeyCode.RightArrow) ) {
		
			mvt= new Vector3(-f_vitesseCourrante, 0, 0) ;
		
		} else {
			// isDeplacement= false ;
			currentAngle= angle_min ;
			mvt= new Vector3(0, 0, 0) ;
		
		}
		updatePosition() ;
	}

	/*-----------------------------------------*/
	// Fonction saut
	/*-----------------------------------------*/
	void saut () {

		// Il faut faire varier l'angle selon v_init.
		v_x= Mathf.Cos (currentAngle * Mathf.Rad2Deg) * v_initSaut ;
		v_y= Mathf.Sin (currentAngle * Mathf.Rad2Deg) * v_initSaut ;

		if ( Input.GetKey(KeyCode.UpArrow) /*if il est a terre*/ ) {
			isJump= true ;
			dtime= Time.deltaTime ;

		} else if ( transform.position.y > 0 ) {
			isJump= false ;
			// Parce que pas de sens de donner une valeur si le mec ne saute plus
			dtime= 0 ;
		}

		updatePosition () ;
	}


	/*--------------------------------------------------*/
	// Fonction de mise à jour de la position du joueur 
	/*--------------------------------------------------*/
	void updatePosition() {
		// Mise à jour de la position pendant le saut.
		Debug.Log ("Vitesse : " + mvt.x) ;
		if ( mvt.x == 0.0f ) {
			// isDeplacement= !isDeplacement ;
		}
		// Si je saute.
		if ( isJump && transform.position.y > 0.0f ) {
			posRelX= (v_x * dtime) ;
			posRelY= ((v_y * dtime) - ((g * dtime * dtime) / 2))  ;
		//Si je ne saute pas.
		} else if ( !isJump && transform.position.y > 0.0f ) {
			posRelX= (v_x * dtime) ;
			posRelY= -((v_y * dtime) - ((g * dtime * dtime) / 2))  ;
		}
		transform.position= new Vector3( (float)(transform.position.x + mvt.x + posRelX),
		                                 (float)(transform.position.y - posRelY),
		                                 transform.position.z ) ;
	}


	/*--------------------------------------------------*/
	// Fonction d'interpolation lineaire de l'angle de saut par rapport à la vitesse de dépalcement
	/*--------------------------------------------------*/
	float interpolationVitesseAngleSaut( float prm_vitesseT ) {

		float f_result= angle_min + ( (angle_max - angle_min) * prm_vitesseT / f_vitesseMax ) ;
		return f_result ;
	}

	/*--------------------------------------------------*/
	// Update is called once per frame
	/*--------------------------------------------------*/
	void Update () {
		// transform.position= new Vector3(transform.position.x + vitesse, transform.position.y, transform.position.z) ;
		deplacement () ;
		saut () ;
		mouvement= 0.0f ;
	
	}
}

